package com.smile.commons.json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.alibaba.fastjson.util.ParameterizedTypeImpl;
import com.alibaba.fastjson.util.TypeUtils;

import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * 泛型反序列化工具类 - 解决Java泛型擦除问题
 * 支持复杂泛型结构的安全转换
 */
public class GenericDeserializer {

    /**
     * 将JSON字符串解析为简单的泛型对象
     *
     * @param json  JSON字符串
     * @param clazz 目标类
     * @param <T>   泛型类型
     * @return 转换后的对象
     */
    public static <T> T parseObject(String json, Class<T> clazz) {
        return JSON.parseObject(json, clazz);
    }

    /**
     * 解析带单个泛型参数的对象 (如ApiResponse<T>)
     *
     * @param json       JSON字符串
     * @param mainClass  主类 (如ApiResponse.class)
     * @param paramClass 泛型参数类 (如XxlJobResult.class)
     * @param <T>        主类类型
     * @param <P>        泛型参数类型
     * @return 转换后的对象
     */
    public static <T, P> T parseSingleGeneric(String json, Class<T> mainClass, Class<P> paramClass) {
        Type type = new ParameterizedTypeImpl(new Type[]{paramClass}, null, mainClass);
        return JSON.parseObject(json, type);
    }

    /**
     * 解析带两个泛型参数的对象 (如Map<K,V>)
     *
     * @param json        JSON字符串
     * @param mainClass   主类
     * @param firstParam  第一个泛型参数类
     * @param secondParam 第二个泛型参数类
     * @param <T>         主类类型
     * @param <K>         第一个泛型类型
     * @param <V>         第二个泛型类型
     * @return 转换后的对象
     */
    public static <T, K, V> T parseDoubleGeneric(String json, Class<T> mainClass,
                                                 Class<K> firstParam, Class<V> secondParam) {
        Type type = new ParameterizedTypeImpl(new Type[]{firstParam, secondParam}, null, mainClass);
        return JSON.parseObject(json, type);
    }

    /**
     * 解析嵌套泛型结构 (如ApiResponse<Map<String, List<XxlJobResult>>>)
     *
     * @param json    JSON字符串
     * @param typeRef 类型引用，使用匿名内部类捕获泛型类型
     * @param <T>     目标类型
     * @return 转换后的对象
     */
    public static <T> T parseComplexGeneric(String json, TypeReference<T> typeRef) {
        return JSON.parseObject(json, typeRef);
    }

    /**
     * 转换泛型列表 (如List<T>)
     *
     * @param json      JSON字符串
     * @param elemClass 列表元素类
     * @param <T>       元素类型
     * @return 转换后的列表
     */
    public static <T> List<T> parseList(String json, Class<T> elemClass) {
        return JSON.parseArray(json, elemClass);
    }

    /**
     * 转换泛型映射 (如Map<K,V>)
     *
     * @param json     JSON字符串
     * @param keyClass 键类型
     * @param valClass 值类型
     * @param <K>      键类型
     * @param <V>      值类型
     * @return 转换后的映射
     */
    public static <K, V> Map<K, V> parseMap(String json, Class<K> keyClass, Class<V> valClass) {
        return JSON.parseObject(json,
                new TypeReference<Map<K, V>>(keyClass, valClass) {
                });
    }

    /**
     * 安全转换任意对象（捕获并处理转换异常）
     *
     * @param json     JSON字符串
     * @param type     目标类型
     * @param fallback 出错时的默认值
     * @param <T>      目标类型
     * @return 转换后的对象或默认值
     */
    public static <T> T safeConvert(String json, Type type, T fallback) {
        try {
            return JSON.parseObject(json, type);
        } catch (Exception e) {
            // 处理异常，返回默认值
            return fallback;
        }
    }
}
